package com.sy.controller.admin;

import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.sy.constant.RedisConstant;
import com.sy.dto.CoursePageQueryDTO;
import com.sy.pojo.Course;
import com.sy.pojo.CourseType;
import com.sy.pojo.CourseUser;
import com.sy.pojo.Coursedetail;
import com.sy.properties.JwtProperties;
import com.sy.result.PageResult;
import com.sy.result.Result;
import com.sy.service.CourseService;
import com.sy.service.CourseTypeService;
import com.sy.service.CourseUserService;
import com.sy.service.CoursedetailService;
import com.sy.utils.FastDFSClient;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiImplicitParam;
import io.swagger.annotations.ApiOperation;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.cache.annotation.CacheEvict;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.web.bind.annotation.*;
import org.springframework.web.multipart.MultipartFile;

import java.time.LocalDateTime;
import java.util.List;

/**
 * 课程管理
 */
@Api(tags = "课程相关接口")
@RestController
@RequestMapping("/admin/course")
@Slf4j
public class CourseController {

    @Autowired
    private CourseService courseService;

    @Autowired
    private CourseTypeService courseTypeService;

    @Autowired
    private JwtProperties jwtProperties;

    @Autowired
    private CoursedetailService coursedetailService;

    @Autowired
    private CourseUserService courseUserService;

    @Autowired
    private StringRedisTemplate redisTemplate;

    @Value("${FILE_SERVER_URL}")
    private String FILE_SERVER_URL;//文件服务器地址

    /**
     * 课程分页查询
     * @param coursePageQueryDTO
     * @return
     */
    @ApiOperation("课程分页查询")
    @GetMapping("/findAll")
    public Result<PageResult> findAll(CoursePageQueryDTO coursePageQueryDTO ) {
        //打印请求数据日志
        log.info("课程分页查询：{}", coursePageQueryDTO);
        //调用业务层实现分页查询
        PageResult pageResult = courseService.findAll(coursePageQueryDTO);
        return Result.success(pageResult);
    }

    /**
     * 课程类型的查询
     * @return
     */
    @ApiOperation("课程类型的查询")
    @GetMapping("/courseTypeList")
    public Result<List<CourseType>> courseTypeList() {
        //调用业务层实现课程类型的查询查询
        List<CourseType> courseTypeList = courseTypeService.list();
        return Result.success(courseTypeList);
    }

    /**
     * 文件上传
     * @param file
     * @return
     */
    @ApiOperation("文件上传")
    @PostMapping("/upload")
    public Result<String> upload(@RequestParam(name = "file") MultipartFile file) {
        try {
        //1、取文件的扩展名box.jpg
        String filename = file.getOriginalFilename();
        //文件后缀名 jpg
        String extName = filename.substring(filename.lastIndexOf(".") + 1);
            //2、执行上传处理
            String path = FastDFSClient.uploadFile(file.getBytes(), extName);
            //3、拼接返回的 url 和 ip 地址，拼装成完整的 url  指的是图片或者这视频在FastDFS服务器中的位置
            String url = FILE_SERVER_URL + path;
            //把上传的成功所有文件名称保存到redis中(没上传成功的文件都要在redis的set集合中记录文件名称)
            //可能是无效文件
            redisTemplate.opsForSet().add(RedisConstant.SETMEAL_PIC_UPLOAD,path);
            return Result.success(url);
        } catch (Exception e) {
            e.printStackTrace();
            throw new RuntimeException("上传失败");
        }
    }

    /**
     * 文件删除
     * @param fileName
     * @return
     */
    @ApiOperation("文件删除")
    @GetMapping("/deleteFile")
    @ApiImplicitParam(name = "fileName", value = "文件名称",
            required = true,dataTypeClass = String.class)
    public Result<String> deleteFile(String fileName) {
        try {
            FastDFSClient.deleteFile(fileName);
            return Result.success();
        } catch (Exception e) {
            //e.printStackTrace();
            throw new RuntimeException("删除失败");
        }
    }

    /**
     * 添加课程
     * @param course
     * @return
     */
    @ApiOperation("添加课程")
    @PostMapping("/save")
    public Result<String> save(@RequestBody Course course) {
        try {
            //设置添加课程的当前时间
            course.setCreateTime(LocalDateTime.now());
            courseService.save(course);
            //添加成功的课程，里边包含的图片和视频地址是有效文件 （有效文件）
            redisTemplate.opsForSet().add(RedisConstant.SETMEAL_PIC_DB, course.getCourseImage());
            redisTemplate.opsForSet().add(RedisConstant.SETMEAL_PIC_DB, course.getCourseVideo());
            return Result.success();
        } catch (Exception e) {
            //e.printStackTrace();
            throw new RuntimeException("修改失败");
        }
    }

    /**
     * 修改课程
     * @param course
     * @return
     */
    @ApiOperation("修改课程")
    @PostMapping("/update")
    @CacheEvict(value = "courseCache",key = "'indexCourses'")
    public Result<String> update(@RequestBody Course course) {
        try {
            //获取当前课程的信息   中的图片路径 和视频路径  删除
            //查询数据库获取的图片和视频的路径  是之前的路径   不是重新上传的路径
            Course oldCourse = courseService.getById(course.getCid());
            courseService.updateById(course);

            //对比老的图片路径与新图片的路径是否一致  如果一致不删除  如果不一致删除老的图片信息
            if (!course.getCourseImage().equals(oldCourse.getCourseImage())){
                FastDFSClient.deleteFile(oldCourse.getCourseImage());
            }
            //比对老的视频路径与新视频的路径是否一致  如果一致不删除  如果不一致删除老的视频信息
            if (!course.getCourseVideo().equals(oldCourse.getCourseVideo())){
                FastDFSClient.deleteFile(oldCourse.getCourseVideo());
            }
            return Result.success();
        } catch (Exception e) {
            //e.printStackTrace();
            throw new RuntimeException("课程修改失败");
        }
    }

    /**
     * 删除课程
     * @param cids
     * @return
     */
    @ApiOperation("删除课程")
    @PostMapping("/delete")
    @ApiImplicitParam(
            name = "cids", value = "课程id的集合",
            required = true, dataTypeClass = List.class
    )
    public Result<String> delete(@RequestBody List<Integer> cids) {
        /**
         * 删除课程前考虑的问题
         * 1.当前课程是否存在课程明细
         * 2.当前课程是否存在用户购买
         */
        try {
        //标识 符合删除条件
        boolean flag = true;
        //遍历cids
        for (Integer cid : cids) {
            //根据cid查询课程表
            Course course = courseService.getById(cid);
            //当前课程是否存在课程明细
            LambdaQueryWrapper<Coursedetail> queryWrapper1 = new LambdaQueryWrapper<>();
            queryWrapper1.eq(Coursedetail::getCid, cid);
            //查询当前课程下是否存在课程明细  查询课程明细的总条数
            int count = coursedetailService.count(queryWrapper1);
            //判断  如果count>0 代表课程下存在课程明细
            if (count > 0) {
                return Result.error("【"+ course.getCourseName() +"】课程下有课程明细，不能删除....");
            }
            //当前课程是否存在用户购买
            LambdaQueryWrapper<CourseUser> queryWrapper2 = new LambdaQueryWrapper<>();
            queryWrapper2.eq(CourseUser::getCid, cid);
            //查询当前课程下是否存在课程明细 查询课程明细的总条数
            int courseUserCount = courseUserService.count(queryWrapper2);
            if (courseUserCount > 0) {
                return Result.error("【"+ course.getCourseName() +"】课程下有用户购买，不能删除....");
            }
        }
            // 删除操作
            if(flag){
                // 获取当前要删除课程的图片和视频的地址
                List<Course> courses = courseService.listByIds(cids);
                courseService.removeByIds(cids);
                for (Course course : courses) {
                    // 删除当前课程的图片
                    FastDFSClient.deleteFile(course.getCourseImage());
                    // 删除当前课程的视频
                    FastDFSClient.deleteFile(course.getCourseVideo());
                }
            }
            return Result.success();
        } catch (Exception e) {
            throw new RuntimeException("课程删除失败");
        }
    }
}
